#include "tipo_int.h"

int TipoInt::invalido = INT_MAX;

TipoInt::TipoInt(const int &val):TipoDato(true){
	this->valor = val;
}
TipoInt::TipoInt():TipoDato(true){
	this->valor = TipoInt::invalido;	
}

bool TipoInt::esta_cargado() const{
	return (this->valor != TipoInt::invalido);	
}

TipoDato& TipoInt::operator= (const TipoDato& dato) throw (ExcepErrorTipos) {
	if (this == &dato)
		return *this;
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo int");
	TipoInt* aux = (TipoInt*) &dato;
	this->valor = aux->valor;
	this->obligatorio = aux->obligatorio;
	return *this;
}

TipoInt& TipoInt::operator= (const int &valor){
	this->valor = valor;
	return *this;
}
	
int TipoInt::get_valor(){
	return this->valor;
}
	
bool TipoInt::operator== (const TipoDato& dato) const throw (ExcepErrorTipos){
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo int");
	TipoInt* aux = (TipoInt*) &dato;
	return (this->valor == aux->valor);
}

bool TipoInt::operator< (const TipoDato& dato) const throw (ExcepErrorTipos){
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo int");
	TipoInt* aux = (TipoInt*) &dato;
	return (this->valor < aux->valor);
}
	
CodTipo TipoInt::get_codigo_tipo() const{
	return INT;
}

TipoDato* TipoInt::clonar() const{
	TipoInt* aux = new TipoInt(this->valor);
	return aux;
}

unsigned int TipoInt::get_tamanio() const{
	return 0;
}

ostream& TipoInt::toStream(ostream& out) const {
	out << this->valor;
	return out;
}


void TipoInt::serializar(char ** retorno, unsigned int &tam){
	tam = sizeof(int);
	*retorno = new char[tam];
	
	//por el momento no chequea error
	*retorno = (char *)memcpy( *retorno, &(this->valor), tam);
}
		
bool TipoInt::deserializar(char * serializados, unsigned int tam){
	if(tam == 4){
		memcpy( &(this->valor), serializados, tam);
		return true;
	}
	return false;
}
unsigned int TipoInt::get_tamanio_serializado(){
	return sizeof(int);	
}
